{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#读取SIFT1M数据集并对其进行聚类\n",
    "import numpy as np\n",
    "import time\n",
    "import os\n",
    "import struct\n",
    "import faiss\n",
    "from vector_helpers import *\n",
    "\n",
    "written = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file_size: 516000000\n",
      "line_size: 516\n",
      "line_count: 1000000\n",
      "iffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 516\n"
     ]
    }
   ],
   "source": [
    "#设置文件路径以及该文件的属性\n",
    "file_path = \"/home/gary/Code/DiskANN/build/data/sift/sift_base.fvecs\"\n",
    "file_size = os.path.getsize(file_path)\n",
    "print(\"file_size:\",file_size)\n",
    "\n",
    "dim = 128\n",
    "dim_size = 4 #以_size结尾的都是占用的字节数\n",
    "vector_size = 512 #每个向量占用的字节数\n",
    "line_size = dim_size+vector_size #每次读取的一行的大小\n",
    "print(\"line_size:\",line_size)\n",
    "\n",
    "vector_count = file_size//line_size\n",
    "print(\"line_count:\",vector_count) #一共有多少个向量\n",
    "\n",
    "#设置数据格式，用于读取文件\n",
    "format_string = 'i'+'f'*dim\n",
    "struct_size = struct.calcsize(format_string)\n",
    "print(format_string, struct_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#根据参数新建numpy数组以存储原始向量\n",
    "vectors = np.empty((vector_count, dim))\n",
    "# print(vectors)\n",
    "# print(vectors.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Open file: /home/gary/Code/DiskANN/build/data/sift/sift_base.fvecs\n",
      "Read 100000 vectors\n",
      "Read 200000 vectors\n",
      "Read 300000 vectors\n",
      "Read 400000 vectors\n",
      "Read 500000 vectors\n",
      "Read 600000 vectors\n",
      "Read 700000 vectors\n",
      "Read 800000 vectors\n",
      "Read 900000 vectors\n",
      "Read 1000000 vectors\n",
      "Read time: 7.9 s\n"
     ]
    }
   ],
   "source": [
    "#读取向量以填充数组。因为sift1M不大，所以我们一次性读取完\n",
    "fd = open(file_path,\"rb\")\n",
    "print(\"Open file:\",file_path)\n",
    "\n",
    "st = time.time()\n",
    "#不一次性读取完，因为有些向量数据集过大是读不完的\n",
    "for i in range(vector_count):\n",
    "    line = fd.read(line_size)\n",
    "    values = struct.unpack_from(format_string, line, 0)\n",
    "    vectors[i] = values[1:]\n",
    "    if((i+1)%100000 == 0):\n",
    "        print(\"Read %d vectors\"%(i+1))\n",
    "et = time.time()\n",
    "print(\"Read time:\",round(et-st,1),\"s\")\n",
    "\n",
    "fd.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read vectors:\n",
      "[[  0.  16.  35. ...  25.  23.   1.]\n",
      " [ 14.  35.  19. ...  11.  21.  33.]\n",
      " [  0.   1.   5. ...   4.  23.  10.]\n",
      " ...\n",
      " [ 30.  12.  12. ...  50.  10.   0.]\n",
      " [  0.   5.  12. ...   1.   2.  13.]\n",
      " [114.  31.   0. ...  25.  16.   0.]]\n"
     ]
    }
   ],
   "source": [
    "#验证读取到的向量\n",
    "print(\"Read vectors:\")\n",
    "print(vectors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start train, trainset interval 1\n",
      "Train time: 2.2 s\n"
     ]
    }
   ],
   "source": [
    "#开始聚类\n",
    "k = 128 #设置聚类数量\n",
    "train_ratio = 1 #设置训练集比例\n",
    "\n",
    "kmeans = faiss.Kmeans(dim, k)\n",
    "\n",
    "step = int(1/train_ratio) #步长，即我们间隔多远取一个向量来训练\n",
    "vectors_train = vectors[::step]\n",
    "\n",
    "print(\"Start train, trainset interval %d\"%step)\n",
    "st = time.time()\n",
    "kmeans.train(vectors_train)\n",
    "et = time.time()\n",
    "print(\"Train time:\",round(et-st,1),\"s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def append_np_array(np_array, file_name):\n",
    "    if(written == False):\n",
    "        return False\n",
    "    # 以二进制追加模式打开文件\n",
    "    with open(file_name, 'ab') as f:\n",
    "        # 将数组转换为bytes并写入文件\n",
    "        np_array.tofile(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "centroids:\n",
      " (128, 128)\n",
      "[[ 52.95939    14.385786    5.3807106 ...  36.14721    38.426395\n",
      "   18.812181 ]\n",
      " [ 31.868526    8.059761    2.2310758 ...  36.294823   16.195219\n",
      "   10.717132 ]\n",
      " [ 60.822964   17.885166    4.8181815 ...  16.282295   38.531097\n",
      "   16.942583 ]\n",
      " ...\n",
      " [  9.847534    3.5201795   5.780269  ...   4.426009    3.0358746\n",
      "    6.7802696]\n",
      " [115.4702     10.392936    0.5474614 ...  20.554085   40.93819\n",
      "    7.3134656]\n",
      " [  8.015267   35.809162   60.839695  ...  13.793893    7.3206105\n",
      "   27.007633 ]]\n"
     ]
    }
   ],
   "source": [
    "#查看训练结果\n",
    "centroids = kmeans.centroids\n",
    "print(\"centroids:\\n\",centroids.shape)\n",
    "print(centroids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Centroid written to: /home/gary/Code/vector-ssd/faiss_test/centroid.bin\n"
     ]
    }
   ],
   "source": [
    "#写入聚类中心文件\n",
    "if(written == True):\n",
    "    centroid_path = \"centroid.bin\"\n",
    "    with open(centroid_path,\"w\") as fd:\n",
    "        pass\n",
    "    for centroid in centroids:    \n",
    "        append_np_array(centroid, centroid_path)\n",
    "\n",
    "    print(\"Centroid written to:\", relative_to_absolute(centroid_path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total search time: 1.5557670593261719 s\n",
      "Average search time: 1.5557670593261719 us\n",
      "(array([[49365.094],\n",
      "       [55820.812],\n",
      "       [40537.656],\n",
      "       ...,\n",
      "       [46929.438],\n",
      "       [69413.03 ],\n",
      "       [41066.406]], dtype=float32), array([[ 13],\n",
      "       [ 67],\n",
      "       [ 13],\n",
      "       ...,\n",
      "       [ 17],\n",
      "       [103],\n",
      "       [126]]))\n"
     ]
    }
   ],
   "source": [
    "#查询所属聚类测试\n",
    "vectors_query = vectors\n",
    "\n",
    "st = time.time()\n",
    "labels = kmeans.index.search(vectors_query, 1)#[1].reshape(-1)\n",
    "et = time.time()\n",
    "print(\"Total search time:\",et-st,\"s\")\n",
    "print(\"Average search time:\",((et-st)*10**6)/len(vectors_query),\"us\")\n",
    "print(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[575876, 945933, 826189, 31623, 53512, 431, 470280, 668239, 242039, 894461]\n",
      "[181.93346, 173.27922, 167.03358, 200.39032, 151.21642, 196.67812, 112.08019, 152.22086, 158.33035, 138.55244]\n",
      "[590012, 49531, 388340, 388345, 222763, 644681, 649279, 912511, 504996, 828556]\n",
      "[384.1188, 415.32898, 418.6751, 399.8506, 378.09073, 408.09183, 336.51096, 405.34387, 366.9411, 414.61218]\n"
     ]
    }
   ],
   "source": [
    "#查询每个向量所属的聚类\n",
    "batch_size = 10000 #设置每次查询多少向量。数据集过大的话不能一次全部查完\n",
    "vector_type_file_path = \"vector_cluster_id.bin\" #设置写入文件路径，里面存的是每个向量所属的聚类\n",
    "centroid_file_path = \"centroid_info.bin\" #设置向量中心信息文件，包含最近和最远节点的id和距离\n",
    "if(written == True):\n",
    "    with open(vector_type_file_path,\"w\") as fd:\n",
    "        pass\n",
    "    with open(centroid_file_path,\"w\") as fd:\n",
    "        pass\n",
    "\n",
    "#查询到一个batch的向量后就写入到vector_cluster_id.bin\n",
    "batch_count = int(vector_count/batch_size) #没有考虑不整除的情况\n",
    "\n",
    "#以下字段用来维护每个聚类中，距离聚类中心最近和最远的向量id和距离\n",
    "nearest_id = [-1]*k\n",
    "nearest_distance = [9999999]*k\n",
    "farest_id = [-1]*k\n",
    "farest_distance = [0]*k\n",
    "vector_id = 0 #记录现在已经是第多少个向量了\n",
    "\n",
    "for i in range(batch_count):\n",
    "    vectors_query = vectors[i*batch_size:(i+1)*batch_size] #构建batch\n",
    "    search_result = kmeans.index.search(vectors_query, 1)\n",
    "    distances = np.sqrt(search_result[0].reshape(-1))\n",
    "    labels = search_result[1].reshape(-1).astype(np.int16)\n",
    "    if(written == True):\n",
    "        append_np_array(labels, vector_type_file_path)\n",
    "    # print(distances)\n",
    "\n",
    "    #获取一批向量的聚类信息后，对比每个向量的所属聚类的状态，更新最近和最远列表\n",
    "    for index, id in enumerate(labels): #index是当前batch下的第多少个向量，id是该向量所属的类别\n",
    "        if distances[index] < nearest_distance[id]:\n",
    "            nearest_id[id] = vector_id\n",
    "            nearest_distance[id] = distances[index]\n",
    "        if distances[index] > farest_distance[id]:\n",
    "            farest_id[id] = vector_id\n",
    "            farest_distance[id] = distances[index]\n",
    "\n",
    "        vector_id += 1\n",
    "\n",
    "#查询完成后写入聚类中心信息到centroid_file\n",
    "print(nearest_id[:10])\n",
    "print(nearest_distance[:10])\n",
    "print(farest_id[:10])\n",
    "print(farest_distance[:10])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Centroid info written to: /home/gary/Code/vector-ssd/faiss_test/centroid_info.bin\n"
     ]
    }
   ],
   "source": [
    "#写入聚类中心信息\n",
    "import math\n",
    "if(written == True):\n",
    "    f = open(centroid_file_path, \"wb\")\n",
    "    for id in range(k):\n",
    "        f.write(struct.pack('i', nearest_id[id]))\n",
    "        f.write(struct.pack('i', farest_id[id]))\n",
    "        f.write(struct.pack('f', nearest_distance[id]))\n",
    "        f.write(struct.pack('f', farest_distance[id]))\n",
    "    f.close()\n",
    "\n",
    "    print(\"Centroid info written to:\",relative_to_absolute(centroid_file_path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index infomation written to: /home/gary/Code/vector-ssd/faiss_test/readme.txt\n"
     ]
    }
   ],
   "source": [
    "#写入当前索引信息的元数据\n",
    "if(written == True):\n",
    "    f = open(\"readme.txt\",\"w\")\n",
    "    f.write(\"%s:存储的是数据集中每个向量所属的聚类，类型为%s\\n\"%(vector_type_file_path,labels.dtype))\n",
    "    f.write(\"%s:存储的是聚类中心的向量，当前索引包含%d个聚类中心，每个聚类中心是一个%d维、%s类型的向量\\n\"%(centroid_path, k,dim,str(centroids.dtype)))\n",
    "    f.write(\"%s:存储的是每个聚类中心最近和最远的节点id、即数据集的第几个向量。一共有%d项，每项分别存储的是最近向量id(类型int32)，最远向量id，最近向量距离(类型float32)，最远向量距离\\n\"%(centroid_file_path,k))\n",
    "    f.close()\n",
    "\n",
    "    print(\"Index infomation written to:\",relative_to_absolute(\"readme.txt\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#测试到底能排除几个\n",
    "query_file_path = \"/home/gary/Code/DiskANN/build/data/sift/sift_query.fvecs\"\n",
    "query_count = 10000\n",
    "query_array = read_fvecs_SIFT1M(query_file_path, 0, query_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10000, 128)\n",
      "[[276.7593  294.83093 302.94586 ... 618.707   620.6889  628.3455 ]\n",
      " [228.94705 242.27425 246.85408 ... 605.5985  607.68304 618.12103]\n",
      " [230.3426  231.39273 235.59467 ... 632.1482  641.4162  646.86316]\n",
      " ...\n",
      " [240.18463 307.85217 308.13647 ... 633.3073  636.97266 648.1986 ]\n",
      " [309.53934 314.75595 336.7888  ... 601.67914 615.81696 621.65186]\n",
      " [268.48236 268.80838 268.85458 ... 633.3153  649.0561  658.24365]]\n",
      "(10000, 128)\n",
      "[[ 87  19  79 ... 102  24 126]\n",
      " [ 91  79  87 ... 102 120  24]\n",
      " [  2  80 120 ...  11  57  39]\n",
      " ...\n",
      " [107  43  37 ...  24 102 126]\n",
      " [ 88 112  21 ...  31 120  24]\n",
      " [ 26  78   1 ...  31 120  24]]\n"
     ]
    }
   ],
   "source": [
    "#获取查询结果\n",
    "L = 10 #候选列表的长度\n",
    "query_result = kmeans.index.search(query_array, k) #这里的k搞错了，k应该是最近的k个向量的含义，这个程序里面的k指的是聚类数量\n",
    "distances = np.sqrt(query_result[0])#.reshape(-1)\n",
    "labels = query_result[1]#.reshape(-1).astype(np.int32)\n",
    "print(distances.shape)\n",
    "print(distances)\n",
    "print(labels.shape)\n",
    "print(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]\n",
      " ...\n",
      " [0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "#获取不可能的聚类\n",
    "#原理是计算每个查询点以查询点为圆心L中的最长距离为半径的圆，与每个聚类中心为圆心以聚类中心最远距离点为半径的圆是否相交\n",
    "#计算方法是对于每个聚类中心，先计算查询点与该聚类中心的距离，然后看这个距离是否大于query_result[L]+该聚类的最大半径（之前算出来的farest_distance），如果大于的话则这个聚类不可能产生候选点\n",
    "invalid_cluster_id = np.zeros(labels.shape,dtype=np.int8) #如果该聚类不可能，则在该id位置置1\n",
    "\n",
    "for i in range(query_count):\n",
    "    cutoff = distances[i][L-1] #获取当前候选列表的最长距离\n",
    "    for j in range(k): #根据cutoff筛选聚类，j为label的下标\n",
    "        if(cutoff+farest_distance[labels[i][j]] < distances[i][j]): #两个圆的半径之和小于圆心距离，说明这两个圆不相交\n",
    "            invalid_cluster_id[i][labels[i][j]] += 1\n",
    "\n",
    "print(invalid_cluster_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 0 3 ... 0 0 0]\n",
      "1.1887\n",
      "排除率: 0.00928671875\n"
     ]
    }
   ],
   "source": [
    "#计算筛除率\n",
    "print(invalid_cluster_id.sum(axis=1))\n",
    "print(invalid_cluster_id.sum(axis=1).mean())\n",
    "print(\"排除率:\",invalid_cluster_id.sum(axis=1).mean()/k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(128, 100000)\n"
     ]
    }
   ],
   "source": [
    "#以下代码用于绘制距离直方图\n",
    "#查询向量所属聚类，然后把这些聚类统计到每个聚类所属的距离列表中\n",
    "cluster_distance_list = np.zeros((k,vector_count//10)) #肯定会造成浪费，目前先不考虑这个问题\n",
    "print(cluster_distance_list.shape)\n",
    "cluster_distance_list_index = [0]*(vector_count//10) #用于标记当前聚类x应该写入第几个位置了"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#查询每个向量所属的聚类\n",
    "batch_size = 10000 #设置每次查询多少向量。数据集过大的话不能一次全部查完\n",
    "\n",
    "#查询到一个batch的向量后就写入到vector_cluster_id.bin\n",
    "batch_count = int(vector_count/batch_size) #没有考虑不整除的情况\n",
    "vector_id = 0 #记录现在已经是第多少个向量了\n",
    "\n",
    "for i in range(batch_count):\n",
    "    vectors_query = vectors[i*batch_size:(i+1)*batch_size] #构建batch\n",
    "    search_result = kmeans.index.search(vectors_query, 1)\n",
    "    distances = np.sqrt(search_result[0].reshape(-1))\n",
    "    labels = search_result[1].reshape(-1).astype(np.int16)\n",
    "\n",
    "    #获取一批向量的聚类信息后，更新每个向量所属聚类的距离列表\n",
    "    for index, label in enumerate(labels): #index是当前batch下的第多少个向量，id是该向量所属的类别\n",
    "        cluster_distance_list[label][cluster_distance_list_index[label]] = distances[index]\n",
    "        cluster_distance_list_index[label] += 1\n",
    "        vector_id += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "# 生成示例数据\n",
    "# data = np.random.randn(1000)\n",
    "for i in range(9):\n",
    "    plt.subplot(3, 3, i+1)\n",
    "    data = cluster_distance_list[i][:cluster_distance_list_index[i]]\n",
    "\n",
    "    # 创建直方图\n",
    "    plt.hist(data, bins=500, color='green', edgecolor='k')\n",
    "    \n",
    "    # 设置标题和轴标签\n",
    "    plt.title('Distances')\n",
    "    plt.xlabel('Distance')\n",
    "    plt.ylabel('Frequency')\n",
    "    \n",
    "# 调整子图之间的间距\n",
    "plt.tight_layout()\n",
    "# 显示图形\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#绘制累计分布函数\n",
    "for i in range(9):\n",
    "    plt.subplot(3, 3, i+1)\n",
    "    data = cluster_distance_list[i][:cluster_distance_list_index[i]]\n",
    "    data_sorted = np.sort(data)\n",
    "    cdf = np.arange(1, len(data_sorted)+1) / len(data_sorted)\n",
    "\n",
    "    # 创建CDF\n",
    "    plt.plot(data_sorted, cdf, marker='.', linestyle='none')\n",
    "    \n",
    "    # 设置标题和轴标签\n",
    "    plt.title('CDF Plot of %d'%i)\n",
    "    plt.xlabel('Distance')\n",
    "    plt.ylabel('CDF')\n",
    "\n",
    "    # 要标注的点\n",
    "    x_value = round(0.8*data_sorted[-1])\n",
    "\n",
    "    # 找到最接近 x_value 的索引\n",
    "    index = np.searchsorted(data_sorted, x_value, side=\"right\")\n",
    "\n",
    "    # 获取相应的 CDF 值\n",
    "    y_value = cdf[index - 1] if index > 0 else 0  # 确保索引不越界\n",
    "\n",
    "    # 标注点\n",
    "    plt.annotate(f'({x_value}, {y_value:.2f})',\n",
    "                xy=(x_value, y_value), xycoords='data',\n",
    "                xytext=(40, 20), textcoords='offset points',\n",
    "                arrowprops=dict(facecolor='black', shrink=0.05))\n",
    "    \n",
    "plt.tight_layout()\n",
    "# 显示图形\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
